import axios from 'axios';
import { showMessage } from '@/utils/axios/httpErrorStatus.js';
import { ToastLoading } from '@/utils/comm.js';
import { baseURL } from '@/utils/baseUrl.js';
import router from '@/router/index.js';
import { addPending, removePending, isFormDataRequest } from '@/utils/axios/requestUtils.js';

/**
 * HTTP请求函数
 * @param {Object} axiosConfig 请求的基本信息，{接口，请求方式，传递参数}
 * @returns {Promise<AxiosResponse<any>>}
 */
axios.defaults.headers['Content-Type'] = 'application/x-www-form-urlencoded'; // 修正拼写错误
async function request(axiosConfig) {
  // 确保参数是对象类型
  axiosConfig.customOptions = axiosConfig.customOptions || {};
  axiosConfig.loadingOptions = axiosConfig.loadingOptions || {};

  // 检测是否为FormData请求
  const isFormData = isFormDataRequest(axiosConfig.params);

  // 设置请求头
  const headers = {
    'Content-Type': isFormData ? 'multipart/form-data' : 'application/json',
    'Accept': 'application/json',
    'Access-Control-Allow-Origin': '*'
  };
  // 创建axios实例
  const service = createAxiosInstance(headers);

  // 设置请求配置
  const custom_option = getRequestOptions(axiosConfig);

  // 配置请求拦截器
  setupRequestInterceptor(service, custom_option);

  // 配置响应拦截器
  setupResponseInterceptor(service, custom_option);

  // 处理FormData请求
  if (isFormData) {
    return handleFormDataRequest(service, axiosConfig);
  }
  axiosConfig.data = axiosConfig.params;
  // 发送普通请求
  return await service(axiosConfig);
}

/**
 * 创建Axios实例
 * @param {Object} headers - 请求头
 * @returns {AxiosInstance} axios实例
 */
function createAxiosInstance(headers) {
  return axios.create({
    baseURL: baseURL,
    timeout: 60 * 1000,
    withCredentials: true,
    headers
  });
}

/**
 * 获取请求配置选项
 * @param {Object} axiosConfig - 请求配置
 * @returns {Object} 合并后的配置选项
 */
function getRequestOptions(axiosConfig) {
  return Object.assign(
    {
      repeat_request_cancel: true,
      loading: axiosConfig.loading ? axiosConfig.loading : false,
      restore_data_format: true,
      error_message_show: true,
      code_message_show: true
    },
    axiosConfig.customOptions
  );
}

/**
 * 设置请求拦截器
 * @param {AxiosInstance} service - axios实例
 * @param {Object} custom_option - 自定义选项
 */
function setupRequestInterceptor(service, custom_option) {
  service.interceptors.request.use((config) => {
    // 处理重复请求
    removePending(config);
    if (custom_option.repeat_request_cancel) {
      addPending(config);
    }

    //可以在这里添加token等认证信息
    const token = getTokenAUTH();
    if (token && typeof window !== 'undefined') {
      config.headers.Authorization = `Bearer ${token}`; // 添加 Bearer 前缀
    }
    return config;
  });
}

/**
 * 获取认证令牌
 * @returns {string|null} token 字符串或 null
 */
function getTokenAUTH() {
  // 假设 token 存储在 localStorage 中，键名为 'token'
  if (typeof window !== 'undefined') {
    return localStorage.getItem('token') || null;
  }
  return null;
}

/**
 * 设置响应拦截器
 * @param {AxiosInstance} service - axios实例
 * @param {Object} custom_option - 自定义选项
 */
function setupResponseInterceptor(service, custom_option) {
  service.interceptors.response.use(
    (response) => handleSuccessResponse(response, custom_option),
    (error) => handleErrorResponse(error, custom_option)
  );
}

/**
 * 处理成功响应
 * @param {Object} response - 响应对象
 * @param {Object} custom_option - 自定义选项
 * @returns {Object} 处理后的响应数据
 */
function handleSuccessResponse(response, custom_option) {
  // 删除请求，避免下次请求被拦截
  removePending(response.config);

  // 检查业务逻辑错误
  if (custom_option.code_message_show && response.data) {
    if (response.data.code !== undefined && response.data.code !== 0 && response.data.code !== 200) {
      ToastLoading(response.data.msg || '请求失败');
      return Promise.reject(response.data);
    }
  }

  // 处理网络错误
  if (response.code === 'ERR_NETWORK') {
    ToastLoading('登录失效，请重新登陆！', 'warning');
    router.replace({ path: '/login' });
    return;
  }

  return custom_option.restore_data_format ? response.data : response;
}

/**
 * 处理错误响应
 * @param {Object} error - 错误对象
 * @param {Object} custom_option - 自定义选项
 * @returns {Promise} 错误Promise
 */
function handleErrorResponse(error, custom_option) {
  // 删除请求记录
  error.config && removePending(error.config);

  // 优先使用后端返回的详细错误信息
  if (error.response?.data) {
    const serverMsg = error.response.data.msg || '未知错误';
    ToastLoading(serverMsg, 'error'); // 直接显示后端提示
    return Promise.reject({ data: { msg: serverMsg } });
  }

  // 处理网络错误
  if (error.message && (error.message.includes('Network Error') || error.message.includes('timeout') || error.message.includes('网络连接不可用'))) {
    ToastLoading('网络连接异常，请检查网络设置', 'warning');
    return Promise.reject({
      data: { msg: '网络连接异常，请检查网络设置' }
    });
  }

  // 处理登录失效
  if (error.response?.status === 401) {
    ToastLoading('登录失效，请重新登陆！');
    router.replace({ path: '/login' });
    return Promise.reject(error);
  }

  // 默认错误提示（如 500 服务器错误）
  const status = error.response?.status || '未知';
  const defaultMsg = `请求异常 [${status}]，请检查输入或联系管理员`;
  ToastLoading(defaultMsg, 'error');
  return Promise.reject({
    data: { msg: defaultMsg }
  });
}

/**
 * 处理FormData请求
 * @param {AxiosInstance} service - axios实例
 * @param {Object} axiosConfig - 请求配置
 * @returns {Promise} 请求Promise
 */
async function handleFormDataRequest(service, axiosConfig) {
  const formDataConfig = {
    ...axiosConfig,
    method: 'post',
    url: axiosConfig.url,
    headers: {
      'Content-Type': 'multipart/form-data'
    },
    data: axiosConfig.params,
    params: undefined
  };

  return await service(formDataConfig);
}

export default request;
